/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package org.trandio.manager;

import com.csvreader.CsvWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.net.URLEncoder;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.naming.NamingException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import javax.servlet.jsp.jstl.core.Config;
import org.trandio.dao.ConfigDAO;
import org.trandio.dao.ConfigInterface;
import org.trandio.dao.GenerarRipsDAO;
import org.trandio.dao.GenerarRipsInterface;
import org.trandio.model.ConfigVO;
import org.trandio.model.PlanoACVO;
import org.trandio.model.PlanoAFVO;
import org.trandio.model.PlanoAHVO;
import org.trandio.model.PlanoAMVO;
import org.trandio.model.PlanoANVO;
import org.trandio.model.PlanoAPVO;
import org.trandio.model.PlanoATVO;
import org.trandio.model.PlanoAUVO;
import org.trandio.model.PlanoCTVO;
import org.trandio.model.PlanoUSVO;
import org.trandio.util.Utiles;

/**
 *
 * @author root
 */
public class GenerarRips extends HttpServlet {

    private GenerarRipsInterface generarRipsInterface;
    private ConfigInterface configInterface;
    private List<PlanoAFVO> listaPlanoAF;
    private List<PlanoUSVO> listaPlanoUS;
    private List<PlanoACVO> listPlanoAC;
    private List<PlanoAPVO> listPlanoAP;
    private List<PlanoAUVO> listPlanoAU;
    private List<PlanoAHVO> listPlanoAH;
    private List<PlanoATVO> listPlanoAT;
    private List<PlanoANVO> listPlanoAN;
    private List<PlanoAMVO> listPlanoAM;
    //   private List<PlanoCTVO> listPlanoCT;
    private ConfigVO configVO;
    ArrayList<ArrayList<String>> nomRipCanReg = new ArrayList<ArrayList<String>>();

    ;

    /**
     * Processes requests for both HTTP
     * <code>GET</code> and
     * <code>POST</code> methods.
     *
     * @param request servlet request
     * @param response servlet response
     * @throws ServletException if a servlet-specific error occurs
     * @throws IOException if an I/O error occurs
     */
    protected void processRequest(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        //response.setContentType("text/plain;charset=UTF-8");
        response.setContentType("text/html;charset=UTF-8");
        PrintWriter out = response.getWriter();


        try {

            int idsede = 0;
            int identidad = 0;
            int idcontrato = 0;
            int caso = 0;
            String factura = "0";

            generarRipsInterface = new GenerarRipsDAO();
            configInterface = new ConfigDAO();

            HttpSession session = request.getSession(true);
            int idPrestador = (Integer) session.getAttribute("idepresed");

            String cc = request.getParameter("cc");
            String fecini = request.getParameter("fecini");
            String fecfin = request.getParameter("fecfin");
            String desentidad = request.getParameter("desentidad");
            String fecgen = request.getParameter("fecgen");

            if (!request.getParameter("idsede").equals("")) {
                idsede = Integer.parseInt(request.getParameter("idsede").trim());
            }

            if (!request.getParameter("identidad").equals("")) {
                identidad = Integer.parseInt(request.getParameter("identidad").trim());
            }
            System.out.println(request.getParameter("idcps"));

            if (!request.getParameter("idcps").equals("null")) {
                idcontrato = Integer.parseInt(request.getParameter("idcps").trim());
            }

            factura = request.getParameter("idfactura");

            //caso I. solo sede
            if ((idsede != 0) && (identidad == 0) && (idcontrato == 0) && (factura.equals(""))) {
                caso = 1;
            }

            // //caso II. solo entidad
            if ((idsede == 0) && (identidad != 0) && (idcontrato == 0) && (factura.equals(""))) {
                caso = 2;
            }

            // //caso III.solo factura
            if ((idsede == 0) && (identidad == 0) && (idcontrato == 0) && !(factura.equals(""))) {
                caso = 3;
            }

            //caso IV. entidad y contrato
            if ((idsede == 0) && (identidad != 0) && (idcontrato != 0) && (factura.equals(""))) {
                caso = 4;
            }

            //caso V. sede y entidad
            if ((idsede != 0) && (identidad != 0) && (idcontrato == 0) && (factura.equals(""))) {
                caso = 5;
            }

            //caso V. sede, entidad y contrato
            if ((idsede != 0) && (identidad != 0) && (idcontrato != 0) && (factura.equals(""))) {
                caso = 6;
            }


            try {
                configVO = configInterface.traerConfig(idPrestador);
            } catch (SQLException ex) {
                Logger.getLogger(GenerarRips.class.getName()).log(Level.SEVERE, null, ex);
            } catch (NamingException ex) {
                Logger.getLogger(GenerarRips.class.getName()).log(Level.SEVERE, null, ex);
            }

            String nomZip = "";
            String[] fecinimostrar = fecini.split("/");
            String[] fecfinmostrar = fecfin.split("/");
            String rutaTotal = configVO.getRutarips() + desentidad + "_" + fecinimostrar[0] + fecinimostrar[1] + fecinimostrar[2] + "_" + fecfinmostrar[0] + fecfinmostrar[1] + fecfinmostrar[2];

            nomZip = desentidad + "_" + fecinimostrar[0] + fecinimostrar[1] + fecinimostrar[2] + "_" + fecfinmostrar[0] + fecfinmostrar[1] + fecfinmostrar[2] + ".zip";

            File carpeta = new File(rutaTotal);
            carpeta.mkdir();

            // OBJETO PARA EL CT

            List<PlanoCTVO> listPlanoCT = new ArrayList<PlanoCTVO>();

            // GENERAR PLANO TRANSACCION

            try {
                listaPlanoAF = generarRipsInterface.generarPlanoTransaccion(caso, idsede, identidad, idcontrato, factura, fecini, fecfin);
                if (!listaPlanoAF.isEmpty()) {
                    String outputFile = rutaTotal + "/" + "AF" + cc + ".txt";
                    PlanoCTVO planoCTVO = new PlanoCTVO();
                    planoCTVO.setCodEntidad(configVO.getCod_pres());
                    planoCTVO.setCodArchivo("AF" + cc);
                    planoCTVO.setFechaRemision(fecgen);
                    planoCTVO.setTotalRegistros(listaPlanoAF.size() + "");
                    listPlanoCT.add(planoCTVO);

                    //               nomRipCanReg.add(new ArrayList());  
                    //((ArrayList)nomRipCanReg.get(0)).add(planoCTVO.getCodArchivo());  
                    //((ArrayList)nomRipCanReg.get(0)).add(Integer.toString(listaPlanoAF.size()));  
                    //matrix.add(new ArrayList());  
                    //((ArrayList)matrix.get(1)).add("row 1 col 0");  
                    //((ArrayList)matrix.get(1)).add("row 1 col 1"); 

                    //nomRipCanReg[0][0] = planoCTVO.getCodArchivo();
                    //nomRipCanReg[0][1] = Integer.toString(listaPlanoAF.size());
                    // before we open the file check to see if it already exists
                    boolean alreadyExists = new File(outputFile).exists();
                    try {
                        // use FileWriter constructor that specifies open for appending
                        CsvWriter csvOutput = new CsvWriter(new FileWriter(outputFile, true), ',');
                        // if the file didn't already exist then we need to write out the header line
			/*
                         * if (!alreadyExists) { csvOutput.write("id");
                         * csvOutput.write("name"); csvOutput.endRecord(); }
                         */
                        // else assume that the file already has the correct header line
                        Iterator af = listaPlanoAF.iterator();
                        double varTotal = 0;
                        double varCopago = 0;
                        while (af.hasNext()) {
                            PlanoAFVO dato = (PlanoAFVO) af.next();
                            try {
                                varTotal = generarRipsInterface.sumarDetalles(dato.getIdFactura());
                                varCopago = generarRipsInterface.copagoDetalles(dato.getIdFactura());
                            } catch (SQLException ex) {
                                Logger.getLogger(GenerarRips.class.getName()).log(Level.SEVERE, null, ex);
                            } catch (NamingException ex) {
                                Logger.getLogger(GenerarRips.class.getName()).log(Level.SEVERE, null, ex);
                            }
                            csvOutput.write(dato.getCodPrestador());
                            csvOutput.write(dato.getNomPrestador());
                            csvOutput.write(dato.getTipoIde());
                            csvOutput.write(dato.getNumeroIde());
                            csvOutput.write(dato.getNumeroFactura());
                            csvOutput.write(dato.getFechaFactura());
                            csvOutput.write(fecini);
                            csvOutput.write(fecfin);
                            csvOutput.write(dato.getCodEntidad());
                            csvOutput.write(dato.getNomEntidad());
                            csvOutput.write(dato.getNumContrato());
                            csvOutput.write(dato.getPlanBeneficio());//buscar de donde traerlo
                            csvOutput.write(dato.getNumPoliza());//buscar origen
                            csvOutput.write(varCopago + "");//calcularlo
                            csvOutput.write(dato.getVrComision());//calcularlo
                            csvOutput.write(dato.getVrDesceunto());//calcularlo
                            csvOutput.write(varTotal + "");//calcular de los detalles
                            csvOutput.endRecord();
                        }
                        csvOutput.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            } catch (SQLException ex) {
                Logger.getLogger(GenerarRips.class.getName()).log(Level.SEVERE, null, ex);
            } catch (NamingException ex) {
                Logger.getLogger(GenerarRips.class.getName()).log(Level.SEVERE, null, ex);
            }
            // GENERAR PLANO DE USUARIOS
            try {
                listaPlanoUS = generarRipsInterface.generarPlanoUsuarios(caso, idsede, identidad, idcontrato, factura, fecini, fecfin);
                if (!listaPlanoUS.isEmpty()) {
                    String outputFileUS = rutaTotal + "/" + "US" + cc + ".txt";
                    PlanoCTVO planoCTUSVO = new PlanoCTVO();
                    planoCTUSVO.setCodEntidad(configVO.getCod_pres());
                    planoCTUSVO.setCodArchivo("US" + cc);
                    planoCTUSVO.setFechaRemision(fecgen);
                    planoCTUSVO.setTotalRegistros(listaPlanoUS.size() + "");
                    listPlanoCT.add(planoCTUSVO);
                    //  nomRipCanReg.add(new ArrayList());  
                    //((ArrayList)nomRipCanReg.get(1)).add(planoCTUSVO.getCodArchivo());  
                    //((ArrayList)nomRipCanReg.get(1)).add(Integer.toString(listaPlanoUS.size()));  

                    //nomRipCanReg[1][0] = planoCTUSVO.getCodArchivo();
                    //nomRipCanReg[1][1] = Integer.toString(listaPlanoUS.size());

                    try {
                        // use FileWriter constructor that specifies open for appending
                        CsvWriter csvOutput = new CsvWriter(new FileWriter(outputFileUS, true), ',');
                        // if the file didn't already exist then we need to write out the header line
			/*
                         * if (!alreadyExists) { csvOutput.write("id");
                         * csvOutput.write("name"); csvOutput.endRecord(); }
                         */
                        // else assume that the file already has the correct header line
                        Iterator at = listaPlanoUS.iterator();
                        while (at.hasNext()) {
                            PlanoUSVO dato = (PlanoUSVO) at.next();
                            csvOutput.write(dato.getTipoIde());
                            csvOutput.write(dato.getNumIde());
                            csvOutput.write(dato.getCodEntidad());
                            csvOutput.write(dato.getTipoUsuario() + "");
                            csvOutput.write(dato.getApe1());
                            csvOutput.write(dato.getApe2());
                            csvOutput.write(dato.getNom1());
                            csvOutput.write(dato.getNom2());
                            csvOutput.write(dato.getEdad() + "");
                            csvOutput.write(dato.getMedidaEdad() + "");
                            csvOutput.write(dato.getSexo());
                            csvOutput.write(dato.getCodDepto());
                            csvOutput.write(dato.getCodMupio());
                            csvOutput.write(dato.getCodZona());
                            csvOutput.endRecord();
                        }
                        csvOutput.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }

            } catch (SQLException ex) {
                Logger.getLogger(GenerarRips.class.getName()).log(Level.SEVERE, null, ex);
            } catch (NamingException ex) {
                Logger.getLogger(GenerarRips.class.getName()).log(Level.SEVERE, null, ex);
            }

            // GENERAR PLANO DE CONSULTAS

            try {
                listPlanoAC = generarRipsInterface.generarPlanoConsultas(caso, idsede, identidad, idcontrato, factura, fecini, fecfin);
                if (!listPlanoAC.isEmpty()) {
                    String outputFileAC = rutaTotal + "/" + "AC" + cc + ".txt";
                    PlanoCTVO planoCTACVO = new PlanoCTVO();
                    planoCTACVO.setCodEntidad(configVO.getCod_pres());
                    planoCTACVO.setCodArchivo("AC" + cc);
                    planoCTACVO.setFechaRemision(fecgen);
                    planoCTACVO.setTotalRegistros(listPlanoAC.size() + "");
                    listPlanoCT.add(planoCTACVO);


                    //  nomRipCanReg.add(new ArrayList());  
                    //((ArrayList)nomRipCanReg.get(2)).add(planoCTACVO.getCodArchivo());  
                    //((ArrayList)nomRipCanReg.get(2)).add(Integer.toString(listPlanoAC.size()));  


                    try {
                        // use FileWriter constructor that specifies open for appending
                        CsvWriter csvOutput = new CsvWriter(new FileWriter(outputFileAC, true), ',');
                        // if the file didn't already exist then we need to write out the header line
			/*
                         * if (!alreadyExists) { csvOutput.write("id");
                         * csvOutput.write("name"); csvOutput.endRecord(); }
                         */
                        // else assume that the file already has the correct header line
                        Iterator at = listPlanoAC.iterator();
                        while (at.hasNext()) {
                            PlanoACVO dato = (PlanoACVO) at.next();
                            csvOutput.write(dato.getNumFactura());
                            csvOutput.write(dato.getCodPrestador());
                            csvOutput.write(dato.getTipoIde());
                            csvOutput.write(dato.getNumIde());
                            csvOutput.write(dato.getFecha());
                            csvOutput.write(dato.getNumOrden());
                            csvOutput.write(dato.getCodActividad());
                            csvOutput.write(dato.getFinalidad());
                            csvOutput.write(dato.getCausaExterna());
                            csvOutput.write(dato.getDxPal());
                            csvOutput.write(dato.getDxRel1());
                            csvOutput.write(dato.getDxRel2());
                            csvOutput.write(dato.getDxRel3());
                            csvOutput.write(dato.getTipoDxId());
                            csvOutput.write(dato.getVrConsulta());
                            csvOutput.write(dato.getVrCoutaMod());
                            csvOutput.write(dato.getVrNeto());
                            csvOutput.endRecord();
                        }
                        csvOutput.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            } catch (SQLException ex) {
                Logger.getLogger(GenerarRips.class.getName()).log(Level.SEVERE, null, ex);
            } catch (NamingException ex) {
                Logger.getLogger(GenerarRips.class.getName()).log(Level.SEVERE, null, ex);
            }

            // GENERAR PLANO DE PROCEDIMIENTOS

            try {
                listPlanoAP = generarRipsInterface.generarPlanoProcedimientos(caso, idsede, identidad, idcontrato, factura, fecini, fecfin);
                if (!listPlanoAP.isEmpty()) {
                    String outputFileAP = rutaTotal + "/" + "AP" + cc + ".txt";
                    PlanoCTVO planoCTAPVO = new PlanoCTVO();
                    planoCTAPVO.setCodEntidad(configVO.getCod_pres());
                    planoCTAPVO.setCodArchivo("AP" + cc);
                    planoCTAPVO.setFechaRemision(fecgen);
                    planoCTAPVO.setTotalRegistros(listPlanoAP.size() + "");
                    listPlanoCT.add(planoCTAPVO);


                    //  nomRipCanReg.add(new ArrayList());  
                    //((ArrayList)nomRipCanReg.get(3)).add(planoCTAPVO.getCodArchivo());  
                    //((ArrayList)nomRipCanReg.get(3)).add(Integer.toString(listPlanoAP.size()));  

                    try {
                        // use FileWriter constructor that specifies open for appending
                        CsvWriter csvOutput = new CsvWriter(new FileWriter(outputFileAP, true), ',');
                        // if the file didn't already exist then we need to write out the header line
			/*
                         * if (!alreadyExists) { csvOutput.write("id");
                         * csvOutput.write("name"); csvOutput.endRecord(); }
                         */
                        // else assume that the file already has the correct header line
                        Iterator at = listPlanoAP.iterator();
                        while (at.hasNext()) {
                            PlanoAPVO dato = (PlanoAPVO) at.next();
                            csvOutput.write(dato.getNumFactura());
                            csvOutput.write(dato.getCodPrestador());
                            csvOutput.write(dato.getTipoIde());
                            csvOutput.write(dato.getNumIde());
                            csvOutput.write(dato.getFecha());
                            csvOutput.write(dato.getNumOrden());
                            csvOutput.write(dato.getCodActividad());
                            csvOutput.write(dato.getAmbito());
                            csvOutput.write(dato.getFinalidad());
                            csvOutput.write(dato.getPeratiende());
                            csvOutput.write(dato.getDxPal());
                            csvOutput.write(dato.getDxRel1());
                            csvOutput.write(dato.getDxComplic());
                            csvOutput.write(dato.getFormaActoQx());
                            csvOutput.write(dato.getVrProc());
                            csvOutput.endRecord();
                        }
                        csvOutput.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            } catch (SQLException ex) {
                Logger.getLogger(GenerarRips.class.getName()).log(Level.SEVERE, null, ex);
            } catch (NamingException ex) {
                Logger.getLogger(GenerarRips.class.getName()).log(Level.SEVERE, null, ex);
            }

            // GENERAR PLANO DE URGENCIAS

            try {
                listPlanoAU = generarRipsInterface.generarPlanoUrgencias(caso, idsede, identidad, idcontrato, factura, fecini, fecfin);
                if (!listPlanoAU.isEmpty()) {
                    String outputFileAU = rutaTotal + "/" + "AU" + cc + ".txt";
                    PlanoCTVO planoCTAUVO = new PlanoCTVO();
                    planoCTAUVO.setCodEntidad(configVO.getCod_pres());
                    planoCTAUVO.setCodArchivo("AU" + cc);
                    planoCTAUVO.setFechaRemision(fecgen);
                    planoCTAUVO.setTotalRegistros(listPlanoAU.size() + "");
                    listPlanoCT.add(planoCTAUVO);

                    //   nomRipCanReg.add(new ArrayList());  
                    //((ArrayList)nomRipCanReg.get(4)).add(planoCTAUVO.getCodArchivo());  
                    //((ArrayList)nomRipCanReg.get(4)).add(Integer.toString(listPlanoAU.size())); 

                    try {
                        // use FileWriter constructor that specifies open for appending
                        CsvWriter csvOutput = new CsvWriter(new FileWriter(outputFileAU, true), ',');
                        // if the file didn't already exist then we need to write out the header line
			/*
                         * if (!alreadyExists) { csvOutput.write("id");
                         * csvOutput.write("name"); csvOutput.endRecord(); }
                         */
                        // else assume that the file already has the correct header line
                        Iterator at = listPlanoAU.iterator();
                        while (at.hasNext()) {
                            PlanoAUVO dato = (PlanoAUVO) at.next();
                            csvOutput.write(dato.getId_factura());
                            csvOutput.write(dato.getCodPrestador());
                            csvOutput.write(dato.getTipoIde());
                            csvOutput.write(dato.getNumIde());
                            csvOutput.write(dato.getFechaIngreso());
                            csvOutput.write(dato.getHoraIngreso());
                            csvOutput.write(dato.getNumOrden());
                            csvOutput.write(dato.getCausaEx());
                            csvOutput.write(dato.getDxPrinEgreso());
                            csvOutput.write(dato.getDxRelEgresoUno());
                            csvOutput.write(dato.getDxRelEgresoDos());
                            csvOutput.write(dato.getDxRelEgresoTres());
                            //csvOutput.write(dato.getDestinoSalEgreso());
                            csvOutput.write(dato.getDestinoSalEgresoId());
                            csvOutput.write(dato.getEstadoSalEgreso());
                            csvOutput.write(dato.getDxMuerteEgreso());
                            csvOutput.write(dato.getFechaEgreso());
                            csvOutput.write(dato.getHoraEgreso());
                            csvOutput.endRecord();
                        }
                        csvOutput.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }

            } catch (SQLException ex) {
                Logger.getLogger(GenerarRips.class.getName()).log(Level.SEVERE, null, ex);
            } catch (NamingException ex) {
                Logger.getLogger(GenerarRips.class.getName()).log(Level.SEVERE, null, ex);
            }

            // GENERAR PLANO DE HOSPITALIZACION

            try {
                listPlanoAH = generarRipsInterface.generarPlanoHospitalizacion(caso, idsede, identidad, idcontrato, factura, fecini, fecfin);
                if (!listPlanoAH.isEmpty()) {
                    String outputFileAH = rutaTotal + "/" + "AH" + cc + ".txt";
                    PlanoCTVO planoCTAHVO = new PlanoCTVO();
                    planoCTAHVO.setCodEntidad(configVO.getCod_pres());
                    planoCTAHVO.setCodArchivo("AH" + cc);
                    planoCTAHVO.setFechaRemision(fecgen);
                    planoCTAHVO.setTotalRegistros(listPlanoAH.size() + "");
                    listPlanoCT.add(planoCTAHVO);

                    // nomRipCanReg.add(new ArrayList());  
                    //((ArrayList)nomRipCanReg.get(5)).add(planoCTAHVO.getCodArchivo());  
                    //((ArrayList)nomRipCanReg.get(5)).add(Integer.toString(listPlanoAH.size())); 
                    try {
                        // use FileWriter constructor that specifies open for appending
                        CsvWriter csvOutput = new CsvWriter(new FileWriter(outputFileAH, true), ',');
                        Iterator at = listPlanoAH.iterator();
                        while (at.hasNext()) {
                            PlanoAHVO dato = (PlanoAHVO) at.next();
                            csvOutput.write(dato.getId_factura());
                            csvOutput.write(dato.getCodPrestador());
                            csvOutput.write(dato.getTipoIde());
                            csvOutput.write(dato.getNumIde());
                            csvOutput.write(dato.getViaIngreso());
                            csvOutput.write(dato.getFechaIngreso());
                            csvOutput.write(dato.getHoraIngreso());
                            csvOutput.write(dato.getNumOrden());
                            csvOutput.write(dato.getCausaEx());
                            csvOutput.write(dato.getDxIngreso());
                            csvOutput.write(dato.getDxEgreso());
                            csvOutput.write(dato.getDxEgreso1());
                            csvOutput.write(dato.getDxEgreso2());
                            csvOutput.write(dato.getDxEgreso3());
                            csvOutput.write(dato.getDxComplic());
                            csvOutput.write(dato.getEstadoSalida());
                            csvOutput.write(dato.getDxMuerte());
                            csvOutput.write(dato.getFechaSalida());
                            csvOutput.write(dato.getHoraSalida());
                            csvOutput.endRecord();
                        }
                        csvOutput.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            } catch (SQLException ex) {
                Logger.getLogger(GenerarRips.class.getName()).log(Level.SEVERE, null, ex);
            } catch (NamingException ex) {
                Logger.getLogger(GenerarRips.class.getName()).log(Level.SEVERE, null, ex);
            }

            // GENERAR PLANO DE OTROS SERVICIOS

            try {
                listPlanoAT = generarRipsInterface.generarPlanoOtroServicios(caso, idsede, identidad, idcontrato, factura, fecini, fecfin);
                if (!listPlanoAT.isEmpty()) {
                    String outputFileAT = rutaTotal + "/" + "AT" + cc + ".txt";
                    PlanoCTVO planoCTATVO = new PlanoCTVO();
                    planoCTATVO.setCodEntidad(configVO.getCod_pres());
                    planoCTATVO.setCodArchivo("AT" + cc);
                    planoCTATVO.setFechaRemision(fecgen);
                    planoCTATVO.setTotalRegistros(listPlanoAT.size() + "");
                    listPlanoCT.add(planoCTATVO);

                    //  nomRipCanReg.add(new ArrayList());  
                    //((ArrayList)nomRipCanReg.get(6)).add(planoCTATVO.getCodArchivo());  
                    //((ArrayList)nomRipCanReg.get(6)).add(Integer.toString(listPlanoAT.size())); 

                    try {
                        // use FileWriter constructor that specifies open for appending
                        CsvWriter csvOutput = new CsvWriter(new FileWriter(outputFileAT, true), ',');
                        Iterator at = listPlanoAT.iterator();
                        while (at.hasNext()) {
                            PlanoATVO dato = (PlanoATVO) at.next();
                            csvOutput.write(dato.getNumFactura());
                            csvOutput.write(dato.getCodPrestador());
                            csvOutput.write(dato.getTipoIde());
                            csvOutput.write(dato.getNumIde());
                            csvOutput.write(dato.getNumOrden());
                            csvOutput.write(dato.getTipoServicio());
                            csvOutput.write(dato.getCodServicio());
                            csvOutput.write(dato.getNomServicio());
                            csvOutput.write(dato.getCantidad());
                            csvOutput.write(dato.getVrUnitario());
                            csvOutput.write(dato.getVrTotal());
                            csvOutput.endRecord();
                        }
                        csvOutput.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            } catch (SQLException ex) {
                Logger.getLogger(GenerarRips.class.getName()).log(Level.SEVERE, null, ex);
            } catch (NamingException ex) {
                Logger.getLogger(GenerarRips.class.getName()).log(Level.SEVERE, null, ex);
            }

            // GENERAR PLANO DE MEDICAMENTOS

            try {
                listPlanoAM = generarRipsInterface.generarPlanoMedicamentos(caso, idsede, identidad, idcontrato, factura, fecini, fecfin);
                if (!listPlanoAM.isEmpty()) {
                    String outputFileAM = rutaTotal + "/" + "AM" + cc + ".txt";
                    PlanoCTVO planoCTAMVO = new PlanoCTVO();
                    planoCTAMVO.setCodEntidad(configVO.getCod_pres());
                    planoCTAMVO.setCodArchivo("AM" + cc);
                    planoCTAMVO.setFechaRemision(fecgen);
                    planoCTAMVO.setTotalRegistros(listPlanoAM.size() + "");
                    listPlanoCT.add(planoCTAMVO);

                    //   nomRipCanReg.add(new ArrayList());  
                    //((ArrayList)nomRipCanReg.get(7)).add(planoCTAMVO.getCodArchivo());  
                    //((ArrayList)nomRipCanReg.get(7)).add(Integer.toString(listPlanoAM.size())); 
                    try {
                        // use FileWriter constructor that specifies open for appending
                        CsvWriter csvOutput = new CsvWriter(new FileWriter(outputFileAM, true), ',');
                        Iterator at = listPlanoAM.iterator();
                        while (at.hasNext()) {
                            PlanoAMVO dato = (PlanoAMVO) at.next();
                            csvOutput.write(dato.getNumFactura());
                            csvOutput.write(dato.getCodPrestador());
                            csvOutput.write(dato.getTipoIde());
                            csvOutput.write(dato.getNumIde());
                            csvOutput.write(dato.getNumOrden());
                            csvOutput.write(dato.getCodMed());
                            csvOutput.write(dato.getTipoMed());
                            csvOutput.write(dato.getNomMed());
                            csvOutput.write(dato.getFormaFarm());
                            csvOutput.write(dato.getConcMed());
                            csvOutput.write(dato.getUndMedida());
                            csvOutput.write(dato.getCantidad());
                            csvOutput.write(dato.getVrUnitario());
                            csvOutput.write(dato.getVrTotal());
                            csvOutput.endRecord();
                        }
                        csvOutput.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            } catch (SQLException ex) {
                Logger.getLogger(GenerarRips.class.getName()).log(Level.SEVERE, null, ex);
            } catch (NamingException ex) {
                Logger.getLogger(GenerarRips.class.getName()).log(Level.SEVERE, null, ex);
            }

            //GENERAR PLANO DE RECIEN NACIDOS

            try {
                listPlanoAN = generarRipsInterface.generarPlanoRecienNacidos(caso, idsede, identidad, idcontrato, factura, fecini, fecfin);
                if (!listPlanoAN.isEmpty()) {
                    String outputFileAN = rutaTotal + "/" + "AN" + cc + ".txt";
                    PlanoCTVO planoCTANVO = new PlanoCTVO();
                    planoCTANVO.setCodEntidad(configVO.getCod_pres());
                    planoCTANVO.setCodArchivo("AN" + cc);
                    planoCTANVO.setFechaRemision(fecgen);
                    planoCTANVO.setTotalRegistros(listPlanoAN.size() + "");
                    listPlanoCT.add(planoCTANVO);

                    // nomRipCanReg.add(new ArrayList());  
                    //((ArrayList)nomRipCanReg.get(8)).add(planoCTANVO.getCodArchivo());  
                    //((ArrayList)nomRipCanReg.get(8)).add(Integer.toString(listPlanoAN.size())); 
                    try {
                        // use FileWriter constructor that specifies open for appending
                        CsvWriter csvOutput = new CsvWriter(new FileWriter(outputFileAN, true), ',');
                        Iterator at = listPlanoAN.iterator();
                        while (at.hasNext()) {
                            PlanoANVO dato = (PlanoANVO) at.next();
                            csvOutput.write(dato.getNumFactura());
                            csvOutput.write(dato.getCodPrestador());
                            csvOutput.write(dato.getTipoIde());
                            csvOutput.write(dato.getNumIde());
                            csvOutput.write(dato.getFechaNacimiento());
                            csvOutput.write(dato.getHoraNacimiento());
                            csvOutput.write(dato.getEdadGestacion());
                            csvOutput.write(dato.getControlPrenatal());
                            csvOutput.write(dato.getSexo());
                            csvOutput.write(dato.getPeso());
                            csvOutput.write(dato.getDxRn());
                            csvOutput.write(dato.getDxMuerte());
                            csvOutput.write(dato.getFechaMuerte());
                            csvOutput.write(dato.getHoraMuerte());
                            csvOutput.endRecord();
                        }
                        csvOutput.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }

            } catch (SQLException ex) {
                Logger.getLogger(GenerarRips.class.getName()).log(Level.SEVERE, null, ex);
            } catch (NamingException ex) {
                Logger.getLogger(GenerarRips.class.getName()).log(Level.SEVERE, null, ex);
            }

            //GENERAR PLANO DE CONTROL

            try {
                // use FileWriter constructor that specifies open for appending
                String outputFileCT = rutaTotal + "/" + "CT" + cc + ".txt";
                CsvWriter csvOutput = new CsvWriter(new FileWriter(outputFileCT, true), ',');

                Iterator at = listPlanoCT.iterator();
                int i = 0;
                while (at.hasNext()) {
                    PlanoCTVO dato = (PlanoCTVO) at.next();
                    csvOutput.write(dato.getCodEntidad());
                    csvOutput.write(dato.getFechaRemision());
                    csvOutput.write(dato.getCodArchivo());
                    csvOutput.write(dato.getTotalRegistros());
                    csvOutput.endRecord();

                    nomRipCanReg.add(new ArrayList());
                    ((ArrayList) nomRipCanReg.get(i)).add(dato.getCodArchivo());
                    ((ArrayList) nomRipCanReg.get(i)).add(dato.getTotalRegistros());
                    i++;
                }


                csvOutput.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

            // COMPRIMIR DIRECTORIO

            try {

                File directoryToZip = new File(rutaTotal);
                List<File> fileList = new ArrayList<File>();
                System.out.println("---Getting references to all files in: " + directoryToZip.getCanonicalPath());
                Utiles.getAllFiles(directoryToZip, fileList);
                System.out.println("---Creating zip file");
                Utiles.writeZipFile(directoryToZip, fileList);
                System.out.println("---Done");

            } catch (Exception e) {
            }


            out.println("<html>");
            out.println("<head>");
            out.println("<title>Cuenta No </title>");
            out.println("</head>");
            out.println("<body>");
            out.println("<div onclick='window.print()' style='float:right; border: 1px solid; cursor:pointer'>");
            out.println("<img src='../common/img/imprimir.gif' width='24px' heigth='24px' />");
            out.println("</div>");
            out.println("<br>");
            //tabla del encabezado
            out.println("<table cellpadding='0' cellspacing='0' style='font-size:9px;' align='center' width='100%'>");
            out.println("<tr>");
            out.println("<th style='border:1px solid;'>Id</th>");
            out.println("<th style='border:1px solid;'>Nombre de Archivo</th>");
            out.println("<th style='border:1px solid;'>Registros</th>");
            out.println("</tr>");
            for (int i = 0; i < nomRipCanReg.size(); i++) {
                out.println("<tr>");
                out.println("<th style='border:1px solid;'>" + i + "</th>");
                for (int y = 0; y < nomRipCanReg.get(i).size(); y++) {

                    out.println("<th style='border:1px solid;'>" + nomRipCanReg.get(i).get(y) + "</th>");
                }
                out.println("</tr>");
            }

            out.println("</table>");
            out.println("<form>");

            out.println("<td><a href=" + "/salus/DownloadFile?fileName=" + URLEncoder.encode(nomZip) + ">" + nomZip + "</a></td></tr>");
            //out.println("<td><a href="+ "/salus/DownloadFile?fileName="+nomZip+">" +nomZip+ "</td></tr>");
            out.println("</form>");
            out.println("</body>");
            out.println("</html>");

        } finally {
            out.close();
        }


    }

    // <editor-fold defaultstate="collapsed" desc="HttpServlet methods. Click on the + sign on the left to edit the code.">
    /**
     * Handles the HTTP
     * <code>GET</code> method.
     *
     * @param request servlet request
     * @param response servlet response
     * @throws ServletException if a servlet-specific error occurs
     * @throws IOException if an I/O error occurs
     */
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        processRequest(request, response);
    }

    /**
     * Handles the HTTP
     * <code>POST</code> method.
     *
     * @param request servlet request
     * @param response servlet response
     * @throws ServletException if a servlet-specific error occurs
     * @throws IOException if an I/O error occurs
     */
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        processRequest(request, response);
    }

    /**
     * Returns a short description of the servlet.
     *
     * @return a String containing servlet description
     */
    @Override
    public String getServletInfo() {
        return "Short description";
    }// </editor-fold>
}
